package jp.co.showbiz.common.util;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtil {

    /**
     * right align
     */
    public static final int RIGHT = 1;

    /**
     * left align
     */
    public static final int LEFT = 2;

 
    public static String subString(String str, int offset, int leng) {
        return new String(str.getBytes(), (offset - 1), leng);
    }


    public static String subString(String str, int offset) {
        byte[] bytes = str.getBytes();
        int size = bytes.length - (offset - 1);
        return new String(bytes, (offset - 1), size);
    }

    /**
     * 주어진 문자열을 대상으로하여 주어진 길이만큼의 문자열을 생성하여 리턴함.
     * <p>
     * 
     * <pre>
     *   (예)
     *  	String str = &quot;abcd&quot;;
     *  	System.out.println(StringUtil.fitString(str,6));
     *  	출력 = &quot;abcd  &quot;
     *  
     *  	String str = &quot;abcd&quot;;
     *  	System.out.println(StringUtil.fitString(str,3));
     *  	출력 = &quot;abc&quot;
     *  
     *  	String str = &quot;가나다라&quot;;
     *  	System.out.println(StringUtil.fitString(str,6));
     *  	출력 = &quot;가나다&quot;
     *  
     *  	String str = &quot;가나다라&quot;;
     *  	System.out.println(StringUtil.fitString(str,3));
     *  	출력 = &quot;???&quot;
     * </pre>
     * @param str 대상 문자열
     * @param size 만들고자 하는 문자열의 길이
     * @return 주어진 길이만큼의 문자
     */

    public static String fitString(String str, int size) {
        return fitString(str, size, StringUtil.LEFT);
    }

    /**
     * 주어진 문자열을 대상으로하여 주어진 길이만큼의 문자열을 생성하여 리턴함.
     * <p>
     * 
     * <pre>
     *   (예)
     *  	String str = &quot;abcd&quot;;
     *  	System.out.println(StringUtil.fitString(str,6,StringUtil.RIGHT));
     *  	출력 = &quot;  abcd&quot;
     * </pre>
     * @param str 대상 문자열
     * @param size 만들고자 하는 문자열의 길이
     * @param align 정열기준의 방향(RIGHT, LEFT)
     * @return 주어진 길이만큼의 문자
     */

    public static String fitString(String str, int size, int align) {
        byte[] bts = str.getBytes();
        int len = bts.length;
        if (len == size) {
            return str;
        }
        if (len > size) {
            String s = new String(bts, 0, size);
            if (s.length() == 0) {
                StringBuffer sb = new StringBuffer(size);
                for (int idx = 0; idx < size; idx++) {
                    sb.append("?");
                }
                s = sb.toString();
            }
            return s;
        }
        if (len < size) {
            int cnt = size - len;
            char[] values = new char[cnt];
            for (int idx = 0; idx < cnt; idx++) {
                values[idx] = ' ';
            }
            if (align == StringUtil.RIGHT) {
                return String.copyValueOf(values) + str;
            } else {
                return str + String.copyValueOf(values);
            }
        }
        return str;
    }

    /**
     * 문자열을 기본분리자(white space)로 분리하여 문자열배열을 생성함
     * @param str 기본 분리자(white space)로 구분된 문자열
     * @return 문자열 배열
     */
    @SuppressWarnings("unchecked")
	public static String[] toStringArray(String str) {
        List list = new ArrayList();
        StringTokenizer st = new StringTokenizer(str);
        while (st.hasMoreTokens()) {
            list.add(st.nextToken());
        }

        return toStringArray(list);
    }

    /**
     * Vector에 저장된 객체들을 이용하여 문자열 배열을 생성함
     * @param list String이 내용으로 들어있는 List 객체
     * @return 문자열 배열
     */
    @SuppressWarnings("unchecked")
	public static String[] toStringArray(List list) {
        String[] strings = new String[list.size()];
        for (int idx = 0; idx < list.size(); idx++) {
            strings[idx] = list.get(idx).toString();
        }
        return strings;
    }

    /**
     * 주어진 문자열에서 지정한 문자열값을 지정한 문자열로 치환후 그결과 문자열을 리턴함.
     * @param src
     * @param from
     * @param to
     * @return 문자열
     */
    public static String replace(String src, String from, String to) {
        if (src == null)
            return null;
        if (from == null)
            return src;
        if (to == null)
            to = "";
        StringBuffer buf = new StringBuffer();
        for (int pos; (pos = src.indexOf(from)) >= 0;) {
            buf.append(src.substring(0, pos));
            buf.append(to);
            src = src.substring(pos + from.length());
        }
        buf.append(src);
        return buf.toString();
    }

    /**
     * 주어진문자열이 지정한 길이를 초과하는 경우 짤라내고 '...'을 붙여 리턴함.
     * @param str
     * @param limit
     * @return 문자열
     */

    public static String cutString(String str, int limit) {

        if (str == null || limit < 4)
            return str;

        int len = str.length();
        int cnt = 0, index = 0;

        while (index < len && cnt < limit) {
            if (str.charAt(index++) < 256) // 1바이트 문자라면...
                cnt++; // 길이 1 증가
            else
                // 2바이트 문자라면...
                cnt += 2; // 길이 2 증가
        }

        if (index < len)
            str = str.substring(0, index - 1) + "...";

        return str;
    }

    /**
     * 스트링에서 특정 문자를 시작으로 끝 문자열까지 삭제한다.
     * @param src
     * @param end
     * @return result 삭제후 값.
     */

    public static String cutEndString(String src, String end) {
        if (src == null)
            return null;
        if (end == null)
            return src;

        int pos = src.indexOf(end);

        if (pos >= 0) {
            src = src.substring(0, pos);
        }

        return src;
    }

    /**
     * 주어진 문자로 원하는 갯수만큼의 char[] 를 생성함.
     * @param c 생성할 문자
     * @param cnt 생성할 갯수
     * @return char array
     */

    public static char[] makeCharArray(char c, int cnt) {
        char[] a = new char[cnt];
        Arrays.fill(a, c);
        return a;
    }

    /**
     * 주어진 문자로 원하는 갯수만큼의 String 을 생성함.
     * @param c 생성할 문자
     * @param cnt 생성할 갯수
     * @return 원하는 갯수 많큼 생성된 문자열
     */

    public static String getString(char c, int cnt) {
        return new String(makeCharArray(c, cnt));
    }

    // 2002-02-07 추가

    /**
     * String의 좌측 공백을 없앤다.
     * @param lstr 대상 String
     * @return String 결과 String
     */

    public static String getLeftTrim(String lstr) {

        if (!lstr.equals("")) {
            int strlen = 0;
            int cptr = 0;
            boolean lpflag = true;
            char chk;

            strlen = lstr.length();
            cptr = 0;
            lpflag = true;

            do {
                chk = lstr.charAt(cptr);
                if (chk != ' ') {
                    lpflag = false;
                } else {
                    if (cptr == strlen) {
                        lpflag = false;
                    } else {
                        cptr++;
                    }
                }
            } while (lpflag);

            if (cptr > 0) {
                lstr = lstr.substring(cptr, strlen);
            }
        }
        return lstr;
    }

    /**
     * String의 우측 공백을 없앤다.
     * @param lstr 대상 String
     * @return String 결과 String
     */

    public static String getRightTrim(String lstr) {
        if (!lstr.equals("")) {
            int strlen = 0;
            int cptr = 0;
            boolean lpflag = true;
            char chk;

            strlen = lstr.length();
            cptr = strlen;
            lpflag = true;

            do {
                chk = lstr.charAt(cptr - 1);
                if (chk != ' ') {
                    lpflag = false;
                } else {
                    if (cptr == 0) {
                        lpflag = false;
                    } else {
                        cptr--;
                    }
                }
            } while (lpflag);

            if (cptr < strlen) {
                lstr = lstr.substring(0, cptr);
            }
        }
        return lstr;
    }

    /**
     * 좌측에서 특정 길이 만큼 취한다.
     * @param str 대상 String
     * @param len 길이
     * @return 결과 String
     */

    public static String getLeft(String str, int len) {
        if (str == null)
            return "";

        return str.substring(0, len);
    }

    /**
     * 우측에서 특정 길이 만큼 취한다.
     * @param str 대상 String
     * @param len 길이
     * @return 결과 String
     */

    public static String getRight(String str, int len) {
        if (str == null)
            return "";

        String dest = "";
        for (int i = (str.length() - 1); i >= 0; i--) {
            dest = dest + str.charAt(i);
        }

        str = dest;
        str = str.substring(0, len);
        dest = "";

        for (int i = (str.length() - 1); i >= 0; i--) {
            dest = dest + str.charAt(i);
        }

        return dest;
    }

    /**
     * 입력된 값이 널이면, replace 값으로 대체한다.
     * @param str 입력
     * @param replace 대체 값
     * @return 문자
     */

    public static String nvl(String str, String replace) {
        if (str == null) {
            return replace;
        } else {
            return str;
        }
    }

    /**
     * Null 또는 공백이면 다른 값으로 대체한다.
     * @param str 입력
     * @param replace 대체 값
     * @return 문
     */

    public static String checkEmpty(String str, String replace) {
        if (str == null || str.equals("")) {
            return replace;
        } else {
            return str;
        }
    }

    /**
     * 문자를 합친다.
     * @param str 문자
     * @return 합쳐진 문자
     */

    public static String capitalize(String str) {
        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return str;
        }
        return new StringBuffer(strLen).append(Character.toTitleCase(str.charAt(0))).append(str.substring(1)).toString();
    }

    /**
     * Exception 정보를 String으로 변환한다.
     * @param e Exception
     * @return String 변환된 Exception
     */

    public static String getErrorTrace(Exception e) {
        if (e == null) {
            return "";
        }
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        e.printStackTrace(pw);

        String errTrace = sw.toString();

        return errTrace;
    }

    /**
     * XML에서 사용하는 특수 문자를 변환한다.
     * @param s
     * @return str
     */

    public static String escapeXml(String s) {
        if (s == null)
            return "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '&') {
                sb.append("&amp;");
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * token문자들을 ArrayList로 반환
     * @param s 구분자를 포함한 문자열
     * @param token 구분자
     * @return List 문자들이 저장된 List object
     */

    @SuppressWarnings("unchecked")
	public static List getTokenList(String s, String token) {
        if (s == null || s.equals(""))
            return null;

        List tokenList = new ArrayList();
        StringTokenizer st = new StringTokenizer(s, token);

        while (st.hasMoreTokens()) {
            tokenList.add(st.nextToken().trim());
        }

        return tokenList;
    }

    /**
     * 구분(token) 문자열(s) 중에서 문자의 카운트를 가져옴
     * @param s 구분자를 포함한 문자열
     * @param token 구분자
     * @return int word count
     */

    public static int getTokenLength(String s, String token) {
        if (s == null)
            return 0;

        int len = 0;
        StringTokenizer st = new StringTokenizer(s, token);
        while (st.hasMoreTokens()) {
            len++;
        }
        return len;
    }

    /**
     * 구분(token) 문자중(s)에서 특정 index번째 문자를 가져옴
     * @param index 가져올 문자의 index
     * @param s 구분자를 포함한 문자열
     * @param token 구분자
     * @return String index번째 문자
     */

    public static String getToken(int index, String s, String token) {
        if (s == null)
            return "";

        StringTokenizer st = new StringTokenizer(s, token);
        StringBuffer sb = new StringBuffer("");
        for (int i = 0; st.hasMoreTokens(); i++) {
            if (index == i) {
                sb.append(st.nextToken());
                break;
            }
            st.nextToken();
        }

        if (sb.toString().length() > 0)
            return sb.toString().trim();
        else
            return "";
    }

    /**
     * 구분(token) 문자중(s)에서 특정 index번째 문자를 가져옴. <BR>
     * 문자(s)가 null일시 nvl반환
     * @param index 가져올 문자의 index
     * @param s 구분자를 포함한 문자열
     * @param token 구분자
     * @param nvl null일째 반환될 nvl
     * @return String index번째 문자
     */

    public static String getToken(int index, String s, String token, String nvl) {
        if (s == null)
            return nvl;

        StringTokenizer st = new StringTokenizer(s, token);
        StringBuffer sb = new StringBuffer("");
        for (int i = 0; st.hasMoreTokens(); i++) {
            if (index == i) {
                sb.append(st.nextToken());
                break;
            }
            st.nextToken();
        }

        if (sb.toString().length() > 0)
            return sb.toString().trim();
        else
            return nvl;
    }

    /**
     * StringBuffer의 내용을 지운다
     * @param strBuf 지울 StringBuffer
     */

    public static void deleteStringBuffer(StringBuffer strBuf) {
        strBuf.delete(0, strBuf.length());
    }

    /**
     * 인자로 주어진 String 객체가 널이 아니고 길이가 0 보다 클 경우 true 리턴한다.
     * @param str 검사할 String
     * @return boolean
     */
    public static boolean isset(String str) {
        return (str != null && str.length() > 0);
    }

    /**
     * 문자열에서 일치하는 문자를 다른 문자로 교체한다.
     * @param htmlStr
     * @return
     */
    public static String collapse(String str, String characters, String replacement) {
        if (str == null) {
            return null;
        }

        StringBuffer newStr = new StringBuffer();

        boolean prevCharMatched = false;
        char c;
        for (int i = 0; i < str.length(); i++) {
            c = str.charAt(i);
            if (characters.indexOf(c) != -1) {
                // this character is matched
                if (prevCharMatched) {
                    // apparently a string of matched chars, so don't append anything
                    // to the string
                    continue;
                }
                prevCharMatched = true;
                newStr.append(replacement);
            } else {
                prevCharMatched = false;
                newStr.append(c);
            }
        }
        return newStr.toString();
    }

    /**
     * 주어진 String이 null이거나 공백이면 UNKNOWN 리턴한다.
     * 
     * <pre>
     * Dependencies : None
     * Side Effects : None
     * </pre>
     * @param str
     * @return
     */
    public static String nullCheck(String str) {
        if (!isset(str)) {
            return "";
        } else {
            return str;
        }
    }

    /**
     * 주어진 String을 byte로 변환하여 max와 비교하는데, 이보다 크면 max 만큼만 잘라서 리턴. 여기서, 국영문이 혼합된 문자열의 마지막 국문자는 잘릴 위험이 있는데 이때, 해당 문자는 버린다.
     * 
     * <pre>
     * Dependencies : None
     * Side Effects : None
     * </pre>
     * @param str
     * @param max
     * @return str
     */
    public static String getString(String str, int max) {

        byte[] temp = str.getBytes();

        int count = 0; // 한글 count
        int str_count = 0;

        while (max > str_count) {

            if (str_count == temp.length)
                break;

            // 한글처럼 2byte 문자의 경우 byte수치가 마이너스로 표시됨
            if (temp[str_count] < 0)
                count++;

            str_count++;
        }

        // 한글이 잘릴경우 버림
        if (count % 2 != 0) {
            str = new String(temp, 0, str_count - 1);
        } else {
            str = new String(temp, 0, str_count);
        }

        return str;
    }

    /**
     * Table object 에서 사용되지 않는 컬럼 체크.
     * 
     * <pre>
     * Dependencies : None
     * Side Effects : None
     * </pre>
     * @param obj Object
     * @return boolean true/false
     */
    public static boolean checkUndefined(Object obj) {

        boolean result = false;

        if (obj.toString().equals("Undefined")) {
            result = true;
        } else {
            result = false;
        }

        return result;
    }

    /**
     * PdaNo에 대시(-)를 넣어 준다.
     * 
     * <pre>
     * Dependencies : None
     * Side Effects : None
     * </pre>
     * @param pdaNo String값
     * @return String 대시된 pda no
     */
    public static String dashedPdaNo(String pdaNo) {

        String firstPdaNo = "";
        String secondPdaNo = "";
        String thirdPdaNo = "";

        if (null == pdaNo || 0 == pdaNo.trim().length()) {
            return "";
        }

        if (pdaNo.trim().length() < 10 || 11 < pdaNo.trim().length()) {
            return pdaNo;
        }

        firstPdaNo = pdaNo.substring(0, 3) + "-";
        secondPdaNo = pdaNo.substring(3, pdaNo.length() - 4) + "-";
        thirdPdaNo = pdaNo.substring(pdaNo.length() - 4);

        return firstPdaNo + secondPdaNo + thirdPdaNo;
    }

    /**
     * @param val
     * @param delim
     * @return
     */
    public static int getDelimCut(String val, char delim) {
        int size = 0;

        if (!ConvertUtil.NullToStr(val).equals("")) {
            char[] arrChar = val.toCharArray();

            for (int i = 0; i < arrChar.length; i++) {
                if (arrChar[i] == delim) {
                    size++;
                }
            }
        }

        return size;
    }

    /**
     * textArea의 Data를 "ENTER" 키를 "br tag"로 바꾸는 Method
     * @param str - textArea의 Data gubun - html 여부 (Y : HTML포함)
     * @return Data의 "ENTER" 키를 "br tag"로 바꾼 String
     *         <p>
     *         <B>기타:</B>
     *         <ul>
     *         <li>작성자 :
     *         <ul>
     */
    public String textAreaToPage(String str, String gubun) {

        /**
         * 
         // 2005.07.07 최정 과장 요청사항
         */
        String result = textRemoveScript(str);

        if (!gubun.equals("N"))
            return result; // html 포함안하는경우 return

        result = replace(result, "&", "&amp;");
        result = replace(result, "<", "&lt;");
        result = replace(result, ">", "&gt;");
        result = replace(result, "'", "&acute;");
        result = replace(result, "\"", "&quot;");
        result = replace(result, "|", "&brvbar;");
        result = replace(result, " ", "&nbsp;");
        result = replace(result, "\n", "<BR>");
        result = replace(result, "\r", "");
        result = replace(result, "\t", "&nbsp;&nbsp;&nbsp;");

        return result;
    }

    /**
     * Method Summary. <br>
     * Method Description.
     * @param str
     * @return description
     * @throws name description
     * @since 1.00
     * @see
     */
    public String textRemoveScript(String str) {
        String result = str;

        result = replace(result, "<script", "&lt;script");
        result = replace(result, "script>", "script&gt;");
        result = replace(result, "<SCRIPT", "&lt;SCRIPT");
        result = replace(result, "SCRIPT>", "SCRIPT&gt;");

        return result;
    }

    /**
     * HTML과 관련하여 일부 특수문자를 변환 example)<br>
     * 
     * <pre>
     * &amp;amp;    ---&gt; &amp; &lt;br&gt;
     * &amp;lt;     ---&gt; &lt; &lt;br&gt;
     * &amp;gt;     ---&gt; &gt; &lt;br&gt;
     * &amp;acute;  ---&gt; ' &lt;br&gt;
     * &amp;cute;   ---&gt; &quot; &lt;br&gt;
     * &amp;brvbar; ---&gt; | &lt;br&gt;
     * </pre>
     * @param String str - 처리대상 문자열
     * @return 지정된 문자로 바꿔진 String
     *         <p>
     *         <B>기타:</B>
     *         <ul>
     *         <li>작성자 :
     *         <ul>
     */
    public String getReplaceSpecialCharacters(String str) {
        str = strReplace(str, "<BR>", "\n");
        str = strReplace(str, "<br>", "\n");
        str = strReplace(str, "&AMP;", "&");
        str = strReplace(str, "&amp;", "&");
        str = strReplace(str, "&LT;", "<");
        str = strReplace(str, "&lt;", "<");
        str = strReplace(str, "&GT;", ">");
        str = strReplace(str, "&gt;", ">");
        str = strReplace(str, "&ACUTE;", "'");
        str = strReplace(str, "&acute;", "'");
        str = strReplace(str, "&QUOT;", "\"");
        str = strReplace(str, "&quot;", "\"");
        str = strReplace(str, "&BRVBAR;", "|");
        str = strReplace(str, "&brvbar;", "|");

        return str;
    }

    /**
     * 스트링에서 특정문자를 치환한다.
     * @param str - 처리대상 문자열
     * @param oldstr - 치환대상 문자
     * @param newstr - 치환 후 문자
     * @return 치환된 String
     *         <p>
     *         <B>기타:</B>
     *         <ul>
     *         <li>작성자 :
     *         <ul>
     */
    public String strReplace(String src, String oldstr, String newstr) {

        if (src == null)
            return null;

        StringBuffer dest = new StringBuffer("");
        int len = oldstr.length();
        int srclen = src.length();
        int pos = 0;
        int oldpos = 0;

        while ((pos = src.indexOf(oldstr, oldpos)) >= 0) {
            dest.append(src.substring(oldpos, pos));
            if ((pos + 1 != srclen) && !"#".equals(src.substring(pos + 1, pos + 2))) {
                dest.append(newstr);
            } else {
                dest.append(oldstr);
            }
            oldpos = pos + len;
        }

        if (oldpos < srclen)
            dest.append(src.substring(oldpos, srclen));

        return dest.toString();
    }

    /*
     * 
     */
	public static String removeImgsize(String text){
		
		Pattern pattern = Pattern.compile("(?i)<img(\\s+height=['\"][0-9]{1,5}['\"]\\salt=['\"]['\"]\\swidth=['\"][0-9]{1,5}['\"])");
//		Pattern pattern = Pattern.compile("(?i)<img(\\s+[a-zA-Z0-9_]*=[^>]*)*(\\s)*(/)?>");

		Matcher  match  =  pattern.matcher(text);
		
        text = match.replaceAll("<img alt=''");
        System.out.println(text);
		
		return text;

    }
}
